import java.util.*;
public class helloyzy {
    public static void main(String[] args) {
        System.out.println("i am yzy " + 1234);



    }


}

class IntCmp implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}


Student s1 = new Student();
s1.age = 10;
s1.name = "ahagnsan";
Student s2 = new Student();
s2.name = "zhagnsan";
s2.age = 9;

AgeComparator ageComparator = new AgeComparator();
System.out.println(ageComparator.compare(s1, s2));


NameComparator nameComparator = new NameComparator();
System.out.println(nameComparator.compare(s1, s2));


class LessIntComp implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1 - o2;
    }
}
//使用比较器创建大根堆
class GreaterIntComp implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}

Set<Map.Entry<Integer, Integer>> ent = map.entrySet();
for (Map.Entry<Integer, Integer> entry : ent) {
    System.out.println(entry.getKey() + "  :  " + entry.getValue());
}

Iterator<String> it = s.iterator();
while (it.hasNext()) {
    System.out.print(it.next() + " ");
}


for (String s : m.keySet()) {
    System.out.print(s + " ");
}
System.out.println();


for (String s : m.values()) {
    System.out.print(s + " ");
}
System.out.println();

for (Map.Entry<String, String> entry : m.entrySet()) {
    System.out.println(entry.getKey() + "--->" + entry.getValue());
}



// foreach遍历
for (int e : list) {
    System.out.print(e + " ");
}
System.out.println();
// 使用迭代器遍历---正向遍历
ListIterator<Integer> it = list.listIterator();
while (it.hasNext()) {
    System.out.print(it.next() + " ");
}
System.out.println();
// 使用反向迭代器---反向遍历
ListIterator<Integer> rit = list.listIterator(list.size());
while (rit.hasPrevious()) {
    System.out.print(rit.previous() + " ");
}



// 1. 不需要参数,返回值为 2
() -> 2
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的和
(x, y) -> x + y
// 4. 接收2个int型整数,返回他们的乘积
(int x, int y) -> x * y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)


public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("Hello");
    list.add("bit");
    list.add("hello");
    list.add("lambda");
    list.sort(new Comparator<String>() {
        @Override
        public int compare(String str1, String str2) {
//注意这里比较长度
            return str1.length() - str2.length();
        }
    });
    System.out.println(list);
}



public static void main(String[] args) {
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "hello");
    map.put(2, "bit");
    map.put(3, "hello");
    map.put(4, "lambda");
    map.forEach(new BiConsumer<Integer, String>() {
        @Override
        public void accept(Integer k, String v) {
            System.out.println(k + "=" + v);
        }
    });
}


public static void main(String[] args) {
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "hello");
    map.put(2, "bit");
    map.put(3, "hello");
    map.put(4, "lambda");
    map.forEach((k, v)-> System.out.println(k + "=" + v));
}


//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a, int b);
}
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a, int b);
}


NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
    @Override
    public void test() {
        System.out.println("hello");
    }
};
noParameterNoReturn.test()




public class TestDemo {
    public static void main(String[] args) {
        NoParameterNoReturn noParameterNoReturn = ()-> {
            System.out.println("无参数无返回值");
        };
        noParameterNoReturn.test();
        OneParameterNoReturn oneParameterNoReturn = (int a)-> {
            System.out.println("一个参数无返回值：" + a);
        };
        oneParameterNoReturn.test(10);
        MoreParameterNoReturn moreParameterNoReturn = (int a, int b)-> {
            System.out.println("多个参数无返回值：" + a + " " + b);
        };
        moreParameterNoReturn.test(20, 30);
        NoParameterReturn noParameterReturn = ()-> {
            System.out.println("有返回值无参数！");
            return 40;
        };
//接收函数的返回值
        int ret = noParameterReturn.test();
        System.out.println(ret);
        OneParameterReturn oneParameterReturn = (int a)-> {
            System.out.println("有返回值有一个参数！");
            return a;
        };
        ret = oneParameterReturn.test(50);
        System.out.println(ret);
        MoreParameterReturn moreParameterReturn = (int a, int b)-> {
            System.out.println("有返回值多个参数！");
            return a + b;
        };
        ret = moreParameterReturn.test(60, 70);
        System.out.println(ret);
    }
}











import java.util.Scanner; //导入Scanner的包
public class code2_0 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//构建一个Scanner对象
        System.out.print("输入数据：");
        String s1 = sc.next(); // 接收一个单词，空格分隔
        System.out.println("接收的单词s1：" + s1);

        String s2 = sc.nextLine(); // 接收一行字符串
        System.out.println("接收的一行字符串s2：" + s2);

        System.out.print("输入整数：");
        if (sc.hasNextInt()) {// 判断输入的是否是整数
            int i = sc.nextInt(); // 接收整数
            System.out.println("整数数据i：" + i);
        } else { // 如果输入的不是整数
            System.out.println("输入的不是整数！");
        }

        System.out.print("输入小数：");
        if (sc.hasNextDouble()) {// 判断输入的是否是小数
            Double f = sc.nextDouble(); // 接收小数
            System.out.println("小数数据f：" + f);
        } else {
            System.out.println("输入的不是小数！");
        }
        sc.close(); //关闭Scanner对象
    }
}


public static void main(String[] args) throws IOException {
    int a = 0;                          // 不要忘记在main函数上抛异常
    int b = 0;
    in.nextToken();                     // 读入数据时，记得每一次读取，都要先in.nextToken()
    a = (int)in.nval;                   // 因为in.nval接收的是double类型，所以要强制类型转换
    in.nextToken();
    b = (int)in.nval;
    out.println("a + b = " + (a + b));

    // 此时输入：hello world!
    in.nextToken();
    String s1 = in.sval;                // 类似于以前的Scanner的next（）方法。
    in.nextToken();                     // 同时也不要忘了in.nextToken()！！！
    String s2 = in.sval;
    out.println(s1);                    // hello
    out.println(s2);                    // world
    // 细心就会发现，为什么读入的是world,而不是world!
    // 其实这就需要看另一篇文章了，参考文章见下方。
    // 此时输入：你好，世界！             // 因为上面输入的是：hello world！所以，下面就还没输入，程序就结束了
    String s = ins.readLine();          // 而输入：hello world 就可以正常进行。

    // 如果要用ins.readLine()读取数字
    // 此时输入类似于 (int)数字 (int)数字
    // 根据题目，我们应该知道输入几个数字，和他们的类型，并根据这些读入读入数据。
    String string = ins.readLine();
    String[] strings = string.split(" ");
    int sa = Integer.parseInt(strings[0]);          // 类似的String转变为Integer方法见下方的图片
    int st = Integer.parseInt(strings[1]);
    out.println(sa);
    out.println(st);

    out.println(s);                     // 所以sval用的时候一定要谨慎考虑输入的数据是否会影响后面数据的读入！！
    out.close();                        // out.close()一定不能忘！否则不输出数据
}




try {
    File file = new File("src\\aa.txt");
    FileInputStream f1 = new FileInputStream(file); //这里需要进行抛出异常处理
    for (int i = 0; i < file.length(); i++) {
        char ch = (char)(f1.read()); //循环读取字符
        System.out.print(ch + " ");
    }
    System.out.println();//换行操作
    f1.close();//关闭文件
} catch (Exception e) {
    // TODO: handle exception
    System.out.println("文件打开失败");
}


import java.io.*;

public class FileWriterDemo {
    public static void main(String[] args) {
        String[] str = {"春眠不觉晓,", "处处闻啼鸟,", "夜来风雨声,", "花落知多少,"};
        File file = new File("src\\cc.txt"); //我们在该类的位置创建一个新文件
        FileWriter f = null; //创建文件写入对象
        BufferedWriter f1 = null; //创建字符流写入对象

        try {
            //这里把文件写入对象和字符流写入对象分开写了
            f = new FileWriter("src\\cc.txt"); //创建一个名为cc.txt的文件
            f1 = new BufferedWriter(f);
            //通过循环遍历上面的String 数组中的元素
            for (int i = 0; i < str.length; i++) {
                f1.write(str[i]);//把String中的字符写入文件
                f1.newLine();//换行操作
            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {//如果没有catch 异常，程序最终会执行到这里
            try {
                f1.close();
                f.close();//关闭文件
            } catch (Exception e2) {
                // TODO: handle exception
            }
        }
    }
}


public static void main(String[] args) {
    File file = new File("src\\cc.txt");
    FileReader f = null; //文件读取对象
    BufferedReader f1 = null; //字符流对象
    try {
        f = new FileReader(file);
        f1 = new BufferedReader(f);
        //循环打印cc文件中的每行数据
        String str = null;
        while ((str = f1.readLine()) != null) {
            System.out.println(str);
        }

    } catch (Exception e) {
        // TODO: handle exception
    } finally {
        try {
            f1.close();
            f.close();
        } catch (Exception e2) {
            // TODO: handle exception
        }
    }
}


while ((len = fr1.read()) != -1) {
    System.out.print((char) len);
}


File file = new File("src\\test.txt"); //我们在该类的位置创建一个新文件
FileWriter f = null; //创建文件写入对象
BufferedWriter f1 = null; //创建字符流写入对象

f = new FileWriter(file); //创建一个名为cc.txt的文件
//f=new FileWriter("src\\test.txt");//创建一个名为cc.txt的文件,操作同上
f1 = new BufferedWriter(f);



public class Util {
//静态的泛型方法 需要在static后用<>声明泛型类型参数
    public static <E> void swap(E[] array, int i, int j) {
        E t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
}


Integer[] a = { ... };
swap(a, 0, 9);
String[] b = { ... };
swap(b, 0, 9);



public class Date {
    public int year;
    public int month;
    public int day;
// 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
// 但是this(1900,1,1);必须是构造方法中第一条语句
    public Date() {
//System.out.println(year); 注释取消掉，编译会失败
        this(1900, 1, 1);
//this.year = 1900;
//this.month = 1;
//this.day = 1;
    }
// 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
}


package com.yzy.demo1;
public class Date {
    public int year = 1900;
    public int month = 1;
    public int day = 1;
    public Date() {
    }
    public Date(int year, int month, int day) {
    }
    public static void main(String[] args) {
        Date d1 = new Date(2021, 6, 9);
        Date d2 = new Date();
    }
}




public class Student {
//实例成员变量
    private String name;
    private String gender;
    private int age;
    private double score;
    public Student() {
        System.out.println("I am Student init()!");
    }
//实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }
    public void show() {
        System.out.println("name: " + name + " age: " + age + " sex: " + sex);
    }
}
public class Main {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.show();
    }
}



public class Student {
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom;
//实例代码块
    {
        this.name = "yzy";
        this.age = 12;
        this.gender = "man";
        System.out.println("I am instance init()!");
    }
// 静态代码块
    static {
        classRoom = "class306";
        System.out.println("I am static init()!");
    }
    public Student() {
        System.out.println("I am Student init()!");
    }
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
    }
}


public class OutClass {
    class InnerClass {
    }
}
// OutClass是外部类
// InnerClass是内部类

public class OutClass {
// 成员位置定义：未被static修饰 --->实例内部类
    public class InnerClass1 {
    }
// 成员位置定义：被static修饰 ---> 静态内部类
    static class InnerClass2 {
    }
    public void method() {
// 方法中也可以定义内部类 ---> 局部内部类：几乎不用
        class InnerClass5 {
        }
    }
}


// 创建实例内部类对象
OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();



// 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
OutClass.InnerClass innerClass2 = outClass.new InnerClass();
innerClass2.methodInner();





public class OutClass {
    private int a;
    static int b;
    public void methodA() {
        a = 10;
        System.out.println(a);
    }
    public static void methodB() {
        System.out.println(b);
    }
// 静态内部类：被static修饰的成员内部类
    static class InnerClass {
        public void methodInner() {
// 在内部类中只能访问外部类的静态成员
// a = 100; // 编译失败，因为a不是类成员变量
            b = 200;
// methodA(); // 编译失败，因为methodB()不是类成员方法
            methodB();
        }
    }
    public static void main(String[] args) {
// 静态内部类对象创建 & 成员访问
        OutClass.InnerClass innerClass = new OutClass.InnerClass();
        innerClass.methodInner();
    }
}

